from IPython.display import YouTubeVideo
YouTubeVideo('uoRZKhA6-Dc', width=560, height=315)

# A biblioteca pandas é usada para carregar, organizar e analisar dados em formato de tabela (linhas e colunas).
import pandas as pd
# O pacote kagglehub permite baixar dados ou modelos diretamente do Kaggle para o notebook, sem precisar acessar o site.
import kagglehub
# Importamos a classe KaggleDatasetAdapter para baixar e acessar datasets públicos do Kaggle diretamente pelo código.
from kagglehub import KaggleDatasetAdapter
# Importa a biblioteca NumPy e a apelida como "np", facilitando o uso de suas funções para cálculos numéricos e manipulação de arrays.
import numpy as np

# Importa o módulo warnings e configura para ignorar mensagens de aviso, evitando que alertas apareçam durante a execução do código.
import warnings
warnings.filterwarnings("ignore")
warnings.simplefilter("ignore")

# Usamos o load_dataset para, vem comigo... ler o conjunto de dados
# "df" é uma convenção bem usada no pandas, vem de "dataframe", é a variável onde nossos dados estarão
# O primeiro parâmetro define que ele será adaptado para PANDAS
# O segundo leva o endereço do conjunto de dados, com o nome da pessoa autora e o nome do conjunto
# O terceiro é o arquivo do conjunto que usaremos, nesse caso, o único disponível
df = kagglehub.dataset_load(
  KaggleDatasetAdapter.PANDAS,
  "uciml/pima-indians-diabetes-database",
  "diabetes.csv",
)

# Antes de qualquer coisa: quantas linhas e quantas colunas temos? (linhas, colunas)
df.shape

(768, 9)

# Exibe as primeiras linhas do conjunto de dados para termos uma ideia de como ele está estruturado.
# Normalmente são as 5 primeira linhas, mas passando 10 por parâmetro, o `.head` mostra 10
df.head(10)

# Mostra um resumo do conjunto de dados, incluindo o tipo de cada coluna e se há valores ausentes.
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 768 entries, 0 to 767
Data columns (total 9 columns):
 #   Column                    Non-Null Count  Dtype  
---  ------                    --------------  -----  
 0   Pregnancies               768 non-null    int64  
 1   Glucose                   768 non-null    int64  
 2   BloodPressure             768 non-null    int64  
 3   SkinThickness             768 non-null    int64  
 4   Insulin                   768 non-null    int64  
 5   BMI                       768 non-null    float64
 6   DiabetesPedigreeFunction  768 non-null    float64
 7   Age                       768 non-null    int64  
 8   Outcome                   768 non-null    int64  
dtypes: float64(2), int64(7)
memory usage: 54.1 KB

# O `.describe()` gera estatísticas como média, mínimo, máximo e quartis para ajudar a entender a distribuição dos dados em cada coluna numérica.
# Com o `round(2)`, arredondamos as estatísticas descritivas para 2 casas decimais para facilitar a leitura.
df.describe().round(2)

# Cria um DataFrame com contagem e porcentagem de zeros por coluna
# Usamos .drop(columns=["Outcome"]) para não pegar a última coluna, `Outcome` que tem zeros por ser binária
# Vale dizer que, usado dessa forma, o `.drop()` não altera nosso dataframe original
def zeros_per_column(dataframe):
    df_zeros = pd.DataFrame({
        'Quantidade de zeros': (dataframe.drop(columns=["Outcome"]) == 0).sum(),
        'Porcentagem (%)': ((dataframe.drop(columns=["Outcome"]) == 0).sum() / dataframe.shape[0] * 100).round(2)
    })
    df_zeros = df_zeros.sort_values(by='Porcentagem (%)', ascending=False)
    return df_zeros

zeros_per_column(df)

# Verifica todas as linhas duplicadas no DataFrame e retorna a quantidade total delas.
df.duplicated().sum()

np.int64(0)

# Importamos a função scatter_matrix para criar gráficos de dispersão entre as variáveis e observar possíveis relações entre elas.
from pandas.plotting import scatter_matrix
# Importamos o Matplotlib com o apelido plt, que será usado para exibir e personalizar gráficos no notebook.
import matplotlib.pyplot as plt
# Importamos a biblioteca Seaborn, que facilita a criação de gráficos estatísticos com visual mais limpo e informativo.
import seaborn as sns
# Importa o módulo math, que fornece funções matemáticas prontas como raízes, potências, trigonometria e constantes (por exemplo, pi).
import math

# Aqui criamos uma grade de gráficos que compara todas as variáveis entre si.
# Isso ajuda a enxergar relações entre os dados e descobrir variáveis que parecem influenciar o diagnóstico de diabetes.
scatter = scatter_matrix(df, figsize=(20, 10))

# Tratamentos na visualização do gráfico para facilita, mas opcional
for ax in scatter.ravel():
    ax.set_xlabel(ax.get_xlabel(), fontsize=8)
    ax.set_ylabel(ax.get_ylabel(), fontsize=8)
    ax.tick_params(axis='both', labelsize=6)
plt.tight_layout()
plt.show()

# Cria um gráfico de dispersão (scatter plot) relacionando a coluna "Outcome" (no eixo X) com "Glucose" (no eixo Y),
# usando alpha=0.1 para deixar os pontos mais transparentes e facilitar a visualização de sobreposições.
df.plot(kind = "scatter", x = "Outcome",  y = "Glucose", alpha = 0.1)

<Axes: xlabel='Outcome', ylabel='Glucose'>

# Visualização com os histogramas de todas as variáveis, focando apenas nas distribuições individuais de cada coluna (sem comparação entre variáveis).
fig, axes = plt.subplots(nrows=3, ncols=3, figsize=(15, 7))

for ax, col in zip(axes.flat, df.columns):
    ax.hist(df[col], bins=30, color='skyblue', edgecolor='black')
    ax.set_title(col)
    ax.set_ylabel("Frequência")
    ax.set_xlabel("Valor")

plt.tight_layout()
plt.show()

# Define a função boxplots que recebe um DataFrame e cria boxplots para todas as suas colunas numéricas.
# Calcula quantos gráficos serão exibidos por linha (cols_per_row) e quantas linhas serão necessárias (rows).
# Cria uma grade de subplots com o tamanho ajustado e transforma o array de eixos em uma lista para iteração.
# Para cada coluna do DataFrame, gera um boxplot usando seaborn com cor verde-claro, define o título e ativa a grade.
# Remove os eixos sobrando (caso o número de colunas não complete a última linha de gráficos).
# Ajusta automaticamente o espaçamento entre os gráficos (tight_layout) e exibe o resultado.

def boxplots(dataframe):
    num_cols = len(dataframe.columns)
    cols_per_row = 5  # quantos gráficos por linha
    rows = math.ceil(num_cols / cols_per_row)

    fig, axes = plt.subplots(rows, cols_per_row, figsize=(cols_per_row * 5, rows * 4))
    axes = axes.flatten()  # deixa em lista para iterar

    for i, col in enumerate(dataframe.columns):
        sns.boxplot(x=dataframe[col], color='lightgreen', ax=axes[i])
        axes[i].set_title(f"Boxplot de {col}")
        axes[i].grid(True)

    # remove eixos vazios (se tiver)
    for j in range(i + 1, len(axes)):
        fig.delaxes(axes[j])

    plt.tight_layout()
    plt.show()

boxplots(df)

# Calculamos a correlação entre todas as variáveis numéricas para entender como elas se relacionam entre si e com o diagnóstico (Outcome).
df.corr()

# Vamos separar os dataframes para, mais pra frente, podermos compará-los e ver a efetividade do nosso tratamento
df_treated = df.copy()

# Conjunto de dados que tínhamos criado anteriormente para visualizar a quantidade e proporção de zeros por colunas
zeros_per_column(df)

# BMI -> Mediana
# Substituímos os valores zero da coluna Glucose pela sua mediana, pois zeros representam dados ausentes e não valores reais.
df_treated.loc[df_treated["BMI"] == 0, "BMI"] = df_treated["BMI"].median()
(df_treated["BMI"] == 0).sum()

np.int64(0)

# Glucose -> Mediana
df_treated.loc[df_treated["Glucose"] == 0, "Glucose"] = df_treated["Glucose"].median()
(df_treated["Glucose"] == 0).sum()

np.int64(0)

# BloodPressure -> Mediana
df_treated.loc[df_treated["BloodPressure"] == 0, "BloodPressure"] = df_treated["BloodPressure"].median()
(df_treated["BloodPressure"] == 0).sum()

np.int64(0)

# Importa a classe KNNImputer do módulo sklearn.impute, usada para preencher valores ausentes no dataset
# com base na média dos vizinhos mais próximos (K-Nearest Neighbors).
from sklearn.impute import KNNImputer

# Substitui os zeros por NaN apenas na SkinThickness
skin_na = df_treated[['SkinThickness', 'BMI', 'Age', 'Glucose']].copy()
skin_na['SkinThickness'] = skin_na['SkinThickness'].replace(0, np.nan)

# Aplica o imputador
imputer = KNNImputer(n_neighbors=5)
skin_imputed = imputer.fit_transform(skin_na)

# Substitui SOMENTE a coluna SkinThickness original com os novos valores imputados
df_treated['SkinThickness'] = skin_imputed[:, 0]

(df_treated["SkinThickness"] == 0).sum()

np.int64(0)

df_treated.head()

# Insulin -> Regressão Linear
# Importamos o modelo de Regressão Linear para prever valores ausentes da variável Insulin com base em outras variáveis do conjunto de dados.
from sklearn.linear_model import LinearRegression

# Fazemos esse teste só para nosso notebook não precisar rodar tudo isso de novo caso o DF na memória já esteja tratado
if ((df_treated["Insulin"] == 0).sum() > 0):
  df_treated['Insulin'] = df_treated['Insulin'].astype(float)

  # 1. Define as entradas que serão usadas para prever a insulina
  features = ['Glucose', 'BMI', 'Age', 'BloodPressure']

  # 2. Separa os dados com valores válidos de Insulin (≠ 0)
  valid_data = df_treated[df_treated['Insulin'] != 0]

  # 3. Separa X e y para treinar o modelo
  X_train_ins = valid_data[features]
  y_train_ins = valid_data['Insulin']

  # 4. Treina o modelo de regressão
  model_insulin = LinearRegression()
  model_insulin.fit(X_train_ins, y_train_ins)

  # 5. Seleciona os dados com Insulin == 0 (ausentes)
  rows_without_data = df_treated[df_treated['Insulin'] == 0]
  X_pred_ins = rows_without_data[features]

  # 6. Usa o modelo para prever os valores ausentes
  predicted_values = model_insulin.predict(X_pred_ins)

  # 7. Substitui os zeros pelos valores preditos
  df_treated.loc[df_treated['Insulin'] == 0, 'Insulin'] = predicted_values

zeros_per_column(df_treated)

# Cria uma grade de subplots com 3 linhas e 3 colunas, definindo o tamanho total da figura como 15x9 polegadas.
# Itera sobre cada eixo (ax) e coluna (col) do DataFrame tratado (df_treated).
# Para cada coluna, plota dois histogramas: um com os dados originais (df) e outro com os dados tratados (df_treated),
# usando cores diferentes e transparência para comparação visual, além de bordas pretas nas barras.
# Define o título como o nome da coluna e adiciona rótulos para os eixos X (Valor) e Y (Frequência).
# Inclui uma legenda para diferenciar os dados "Antes" e "Depois".
# Ajusta automaticamente o espaçamento entre os gráficos (tight_layout) e exibe o resultado.
fig, axes = plt.subplots(nrows=3, ncols=3, figsize=(15, 9))

for ax, col in zip(axes.flat, df_treated.columns):
    ax.hist(df[col], bins=30, color='lightgray', alpha=0.6, label='Antes', edgecolor='black')
    ax.hist(df_treated[col], bins=30, color='skyblue', alpha=0.6, label='Depois', edgecolor='black')
    ax.set_title(col)
    ax.set_ylabel("Frequência")
    ax.set_xlabel("Valor")
    ax.legend()

plt.tight_layout()
plt.show()

# Antes de qualquer coisa, deixaremos esse o `df_treated_with_outliers` como backup e trataremos o `df_treated`
df_treated_with_outliers = df_treated.copy()

boxplots(df_treated)

# Importa a função boxcox do módulo scipy.stats, usada para aplicar a transformação Box-Cox em dados, tornando distribuições mais próximas da normalidade.
from scipy.stats import boxcox

cols = ['BloodPressure', 'SkinThickness','Insulin', 'BMI', 'DiabetesPedigreeFunction']

for col in cols:
    original = df_treated[col].values

    # Garantir que todos sejam > 0 para as transformações
    min_val = original.min()
    if min_val <= 0:
        shift = abs(min_val) + 1
        original_shifted = original + shift
    else:
        shift = 0
        original_shifted = original.copy()

    # Transformações
    log_transformed = np.log(original_shifted)
    boxcox_transformed, fitted_lambda = boxcox(original_shifted)

    # Plot
    fig, axes = plt.subplots(1, 3, figsize=(15, 4))
    sns.histplot(original, ax=axes[0], kde=True, color="skyblue")
    axes[0].set_title(f"{col} - Original")

    sns.histplot(log_transformed, ax=axes[1], kde=True, color="orange")
    axes[1].set_title(f"{col} - Log (shift={shift})")

    sns.histplot(boxcox_transformed, ax=axes[2], kde=True, color="green")
    axes[2].set_title(f"{col} - Box-Cox λ={fitted_lambda:.2f} (shift={shift})")

    plt.suptitle(f"Comparação de transformações para {col}")
    plt.tight_layout()
    plt.show()

# Dicionário para salvar os lambdas de cada coluna
boxcox_lambdas = {}

# Lista das colunas que vamos transformar com Box-Cox
cols_boxcox = [
    'BloodPressure',
    'SkinThickness',
    'Insulin',
    'BMI',
    'DiabetesPedigreeFunction'
]

for col in cols_boxcox:
    data = df_treated[col].values

    # Box-Cox exige valores estritamente positivos
    min_val = data.min()
    if min_val <= 0:
        shift = abs(min_val) + 1
        data = data + shift
    else:
        shift = 0

    # Aplica Box-Cox
    transformed, fitted_lambda = boxcox(data)

    # Salva no dataframe transformado
    df_treated[col] = transformed

    # Guarda o lambda e o shift usado
    boxcox_lambdas[col] = {
        'lambda': fitted_lambda,
        'shift': shift
    }

boxplots(df_treated)

# Importa o módulo random, que fornece funções para geração de números aleatórios e seleção aleatória de elementos.
import random

# Define a constante RANDOM_STATE com o valor 872008, usada para fixar a semente aleatória e garantir reprodutibilidade nos resultados.
RANDOM_STATE = 872008

# Configura a semente aleatória do módulo random e do NumPy com o valor de RANDOM_STATE,
# garantindo que qualquer operação aleatória produza sempre os mesmos resultados.
random.seed(RANDOM_STATE)
np.random.seed(RANDOM_STATE)

# X representa os dados de entrada (também chamados de "features" ou "variáveis explicativas", ou "atributos" como estavamos chamando).
# No nosso caso, tudo que não é a coluna `Outcome` influencia no resultado.
X = df_treated.drop(columns=["Outcome"])
X.head()

# Y representa a resposta esperada, ou seja, o alvo que queremos que o modelo aprenda a prever.
Y = df_treated['Outcome']
Y.head()

0    1
1    0
2    1
3    0
4    1
Name: Outcome, dtype: int64

# Importamos a função que permite dividir os dados em conjuntos de treino e teste, o que é essencial para avaliar a capacidade do modelo de generalizar para novos dados.
from sklearn.model_selection import train_test_split

# Dividimos os dados em treino (80%) e teste (20%) de forma aleatória, mas reprodutível. Isso permite treinar o modelo e depois avaliá-lo com dados que ele nunca viu.
raw_x_train, raw_x_test, y_train, y_test = train_test_split(X, Y, test_size=0.20, stratify = Y, random_state=RANDOM_STATE)

# Importamos o StandardScaler para padronizar os dados, deixando todas as variáveis com média 0 e desvio padrão 1 — isso ajuda muitos modelos a terem um desempenho melhor.
from sklearn.preprocessing import StandardScaler

# Criamos o objeto StandardScaler, que será usado para padronizar os dados numéricos (média 0, desvio padrão 1).
scaler = StandardScaler()

# Aqui, o scaler aprende a média e o desvio padrão de cada coluna dos dados de entrada, preparando-se para padronizá-los.
scaler.fit(raw_x_train)

# Aplicamos a padronização nos dados, transformando as variáveis para que tenham média 0 e desvio padrão 1 — o que ajuda muitos modelos a ter um melhor desempenho.
x_train = scaler.transform(raw_x_train)
x_test = scaler.transform(raw_x_test)


x_train = pd.DataFrame(
    scaler.transform(raw_x_train),
    columns=raw_x_train.columns,
    index=raw_x_train.index
)

x_test = pd.DataFrame(
    scaler.transform(raw_x_test),
    columns=raw_x_test.columns,
    index=raw_x_test.index
)

def train_test_split_inner(dataframe, use_scaler):
    X = dataframe.drop(columns=["Outcome"])
    Y = dataframe["Outcome"]

    raw_x_train, raw_x_test, y_train, y_test = train_test_split(
        X, Y,
        test_size=0.20,
        stratify=Y,
        random_state=RANDOM_STATE
    )

    if use_scaler:
        scaler = StandardScaler()
        scaler.fit(raw_x_train)

        x_train = pd.DataFrame(
            scaler.transform(raw_x_train),
            columns=raw_x_train.columns,
            index=raw_x_train.index
        )

        x_test = pd.DataFrame(
            scaler.transform(raw_x_test),
            columns=raw_x_test.columns,
            index=raw_x_test.index
        )

        return x_train, x_test, y_train, y_test

    return raw_x_train, raw_x_test, y_train, y_test

# Importa a função time do módulo time, que retorna o horário atual em segundos desde a época Unix, útil para medir a duração de processos.
from time import time
# Importa do módulo sklearn.metrics as funções accuracy_score, precision_score, recall_score e f1_score, usadas para avaliar o desempenho de modelos de Machine Learning.
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Importa uma ampla variedade de algoritmos de classificação de diferentes módulos do scikit-learn, além dos classificadores XGBClassifier (XGBoost) e LGBMClassifier (LightGBM).
# Esses modelos incluem métodos lineares, de vizinhos, árvores de decisão, florestas aleatórias, boosting, redes neurais, Naive Bayes, SVM e classificadores de base (Dummy),
# permitindo testar e comparar múltiplas abordagens de Machine Learning em tarefas de classificação.
from sklearn.linear_model import LogisticRegression, SGDClassifier, RidgeClassifier, PassiveAggressiveClassifier, Perceptron
from sklearn.svm import SVC
from sklearn.ensemble import (
    GradientBoostingClassifier, ExtraTreesClassifier, BaggingClassifier,
    AdaBoostClassifier, RandomForestClassifier, HistGradientBoostingClassifier,
    VotingClassifier, StackingClassifier
)
from sklearn.naive_bayes import GaussianNB, BernoulliNB, MultinomialNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis
from sklearn.calibration import CalibratedClassifierCV
from sklearn.neural_network import MLPClassifier
from sklearn.dummy import DummyClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier

class TrainResult:
  def __init__(self, name, classifier, accuracy, precision, recall, f1, time):
    self.name = name
    self.classifier = classifier
    self.accuracy = accuracy
    self.precision = precision
    self.recall = recall
    self.f1 = f1
    self.time = time

  def __str__(self):
      return (
          f"{self.name}\n" +
          "Acurácia : {0:.2f}%\n".format(self.accuracy) +
          "Precisão : {0:.2f}%\n".format(self.precision) +
          "Recall Score: {0:.2f}%\n".format(self.recall) +
          "F1 Score : {0:.2f}%\n".format(self.f1) +
          "Tempo de treino e teste: {0:.2f}s\n".format(self.time)
      )

# Define a função train_models, que treina e avalia diversos modelos de classificação em um conjunto de dados.
# Recebe como parâmetros os conjuntos de treino e teste (x_train, x_test, y_train, y_test).
# Cria uma lista "models" com tuplas contendo o nome do modelo e sua instância, incluindo diferentes algoritmos de Machine Learning.
# Inicializa a lista "results" para armazenar os resultados de cada modelo.
# Para cada modelo na lista:
#   - Marca o tempo inicial (t0) para medir desempenho.
#   - Treina o modelo com os dados de treino (fit).
#   - Faz previsões no conjunto de teste (predict).
#   - Calcula o tempo total de treino e teste.
#   - Calcula métricas de avaliação: acurácia, precisão, recall e F1-score (em porcentagem).
#   - Armazena as métricas e o tempo em um objeto TrainResult e adiciona à lista "results".
# Retorna a lista de resultados, contendo as métricas e os tempos para todos os modelos avaliados.
def train_models(x_train, x_test, y_train, y_test):
  models = [
    ("Logistic Regression", LogisticRegression(random_state=RANDOM_STATE)),
    ("SVC", SVC(random_state=RANDOM_STATE)),
    ("Gradient Boosting Classifier", GradientBoostingClassifier(random_state=RANDOM_STATE)),
    ("Extra Trees Classifier", ExtraTreesClassifier(random_state=RANDOM_STATE)),
    ("Bagging Classifier", BaggingClassifier(random_state=RANDOM_STATE)),
    ("AdaBoost Classifier", AdaBoostClassifier(random_state=RANDOM_STATE)),
    ("Gaussian NB", GaussianNB()),
    ("Bernoulli NB", BernoulliNB()),
    ("MLP Classifier", MLPClassifier(random_state=RANDOM_STATE)),
    ("XGB Classifier", XGBClassifier(random_state=RANDOM_STATE)),
    ("LGBM Classifier", LGBMClassifier(verbose=-1, random_state=RANDOM_STATE)),
    ("K Nearest Neighbour Classifier", KNeighborsClassifier()),
    ("Decision Tree Classifier", DecisionTreeClassifier(random_state=RANDOM_STATE)),
    ("Random Forest Classifier", RandomForestClassifier(random_state=RANDOM_STATE)),
    ("LDA", LinearDiscriminantAnalysis()),
    ("QDA", QuadraticDiscriminantAnalysis()),
    ("SGD-Log", SGDClassifier(loss="log_loss", alpha=1e-3, class_weight="balanced", max_iter=2000, random_state=RANDOM_STATE)),
    ("RidgeClf", RidgeClassifier(random_state=RANDOM_STATE)),
    ("HGB", HistGradientBoostingClassifier(random_state=RANDOM_STATE)),
    ("Calibrated SVC", CalibratedClassifierCV(cv=5)),
    ("Passive Aggressive", PassiveAggressiveClassifier(random_state=RANDOM_STATE)),
    ("Perceptron", Perceptron(random_state=RANDOM_STATE)),
    ("Dummy Classifier", DummyClassifier(strategy="most_frequent"))
  ]

  results = []

  for name, classifier in models:
    t0 = time()

    classifier.fit(x_train, y_train)
    pred_y = classifier.predict(x_test)

    train_test_time = time() - t0

    acc = accuracy_score(y_test, pred_y) * 100
    pre = precision_score(y_test, pred_y) * 100
    rec = recall_score(y_test, pred_y) * 100
    f1 = f1_score(y_test, pred_y) * 100

    results.append(TrainResult(name, classifier, acc, pre, rec, f1, train_test_time))

  return results

# Chama a função train_models passando os conjuntos de treino e teste,
# executa o treinamento e avaliação de todos os modelos definidos e
# armazena a lista de resultados (métricas e tempos) na variável results.
results = train_models(x_train, x_test, y_train, y_test)

# Vamos só printar uma delas para ver o resultado:
print(results[0])

Logistic Regression
Acurácia : 76.62%
Precisão : 70.45%
Recall Score: 57.41%
F1 Score : 63.27%
Tempo de treino e teste: 0.01s

# Importa o módulo ipywidgets como widgets, que permite criar elementos interativos (como botões e sliders) em notebooks Jupyter.
# Também importa as funções display e clear_output de IPython.display,
# usadas para exibir objetos na célula e limpar saídas anteriores, respectivamente.
import ipywidgets as widgets
from IPython.display import display, clear_output

# --- sua função, agora parametrizada por 'sort_by'
def plot_results_summary(results, sort_by='Recall'):
    # -> DataFrame
    df = pd.DataFrame({
        'Modelo':   [r.name for r in results],
        'Acurácia': [r.accuracy for r in results],
        'Precisão': [r.precision for r in results],
        'Recall':   [r.recall for r in results],
        'F1-score': [r.f1 for r in results],
        'Tempo (s)': [r.time for r in results],
    })

    # métrica escolhida: desc p/ métricas de qualidade, asc p/ tempo
    descending = sort_by != 'Tempo (s)'
    df = df.sort_values(sort_by, ascending=not descending).reset_index(drop=True)

    # Figura com 2 painéis: (heatmap | lollipop do tempo)
    sns.set_theme(style="whitegrid")
    fig = plt.figure(figsize=(30, 9))
    gs = fig.add_gridspec(nrows=1, ncols=2, width_ratios=[3.0, 1.6], wspace=0.25)

    # --- Painel 1: Heatmap de métricas (0-100%)
    ax0 = fig.add_subplot(gs[0, 0])
    metrics = df.set_index('Modelo')[['Acurácia', 'Precisão', 'Recall', 'F1-score']]
    hm = sns.heatmap(
        metrics,
        annot=True, fmt=".1f", cmap="YlGnBu",
        vmin=0, vmax=100, linewidths=0.5, linecolor='white',
        cbar=False, ax=ax0
    )
    ax0.set_title(f"Acurácia, Precisão, Recall e F1 (%) — ordenado por {sort_by}")
    ax0.set_xlabel(""); ax0.set_ylabel("")

    # --- Painel 2: Lollipop de tempo
    ax1 = fig.add_subplot(gs[0, 1])
    y = np.arange(len(df))
    x = df['Tempo (s)'].values
    ax1.hlines(y=y, xmin=0, xmax=x, color='lightgray', lw=2, zorder=1)
    ax1.plot(x, y, 'o', ms=8, zorder=2)
    ax1.set_yticks(y); ax1.set_yticklabels(df['Modelo'])
    ax1.invert_yaxis()  # topo = melhor conforme ordenação aplicada

    if (x.max() / max(x.min(), 1e-9)) > 15:
        ax1.set_xscale('log'); ax1.set_xlabel("Tempo (s) — escala log")
    else:
        ax1.set_xlabel("Tempo (s)")
    ax1.set_title("Velocidade de treino+teste")

    for xi, yi in zip(x, y):
        ax1.annotate(f"{xi:.2f}s", (xi, yi),
                     xytext=(6, 0), textcoords="offset points",
                     va='center', fontsize=9)

    fig.suptitle("Comparativo único de qualidade (heatmap) e velocidade (lollipop)", y=0.98, fontsize=14)
    plt.tight_layout()
    plt.show()

# --- widget de ordenação
dd = widgets.Dropdown(
    options=['Recall', 'F1-score', 'Precisão', 'Acurácia', 'Tempo (s)'],
    value='Recall',
    description='Ordenar por:',
)

out = widgets.Output()

def _redraw(change=None):
    with out:
        clear_output(wait=True)
        plot_results_summary(results, sort_by=dd.value)

dd.observe(_redraw, names='value')

display(dd)
_redraw()
display(out)

# Importa a função confusion_matrix, que calcula a matriz de confusão para avaliar classificadores,
# e ConfusionMatrixDisplay, que facilita a visualização gráfica dessa matriz.
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

def plot_confusion_matrix(df, results):
  x_train, x_test, y_train, y_test = train_test_split_inner(df, True)

  n_models = len(results)
  fig, axes = plt.subplots(1, n_models, figsize=(5*n_models, 4))

  # Garantir que axes seja iterável mesmo quando há apenas 1 modelo
  if n_models == 1:
      axes = [axes]

  for ax, result in zip(axes, results):
      # Previsões do modelo
      y_pred = result.classifier.predict(x_test)
      cm = confusion_matrix(y_test, y_pred)

      disp = ConfusionMatrixDisplay(confusion_matrix=cm,
                                    display_labels=result.classifier.classes_)
      disp.plot(cmap=plt.cm.Blues, ax=ax, colorbar=False)
      ax.set_title(result.name)

  plt.tight_layout()
  plt.show()

models = [
    next((e for e in results if e.name == "SGD-Log"), None),
    next((e for e in results if e.name == "Gaussian NB"), None)
]

plot_confusion_matrix(df_treated, models)

# Importa a função permutation_importance do módulo sklearn.inspection,
# usada para avaliar a importância das features medindo a queda de desempenho do modelo
# quando os valores de uma feature são embaralhados aleatoriamente.
from sklearn.inspection import permutation_importance

def plot_feature_importance(df, results, top_n=10):
    X = df.drop(columns=["Outcome"])
    y = df["Outcome"]
    feat = X.columns.to_numpy()

    fig, axes = plt.subplots(1, len(results), figsize=(6*len(results), 5))
    if len(results) == 1:
        axes = [axes]

    for ax, r in zip(axes, results):
        m = r.classifier
        if hasattr(m, "feature_importances_"):
            imp = m.feature_importances_
        elif hasattr(m, "coef_"):
            imp = np.abs(m.coef_[0])
        else:
            pi = permutation_importance(m, X, y, n_repeats=5, random_state=42)
            imp = pi.importances_mean

        idx = np.argsort(imp)[-top_n:]
        ax.barh(feat[idx], imp[idx])
        ax.set_title(r.name)
    plt.tight_layout()
    plt.show()

plot_feature_importance(df, models)

# Importa a biblioteca SHAP, utilizada para explicar as previsões de modelos de Machine Learning
# atribuindo a cada feature um valor de importância baseado na teoria dos valores de Shapley.
import shap
# Função que retorna True se o modelo for baseado em árvores de decisão (scikit-learn, XGBoost ou LightGBM), caso contrário retorna False.
def _is_tree_model(model) -> bool:
    tree_types = (DecisionTreeClassifier, RandomForestClassifier,
                  ExtraTreesClassifier, GradientBoostingClassifier, AdaBoostClassifier)
    return (isinstance(model, tree_types) or
            (XGBClassifier != object and isinstance(model, XGBClassifier)) or
            (LGBMClassifier != object and isinstance(model, LGBMClassifier)))

# Retorna True se o modelo for uma instância de LogisticRegression, caso contrário retorna False.
def _is_linear_model(model) -> bool:
    return isinstance(model, LogisticRegression)

# Prepara os dados de entrada (X) para o modelo.
# Se receber um DataFrame, remove a coluna "Outcome" (se existir) e retorna X junto com a lista dos nomes das colunas.
# Se não for DataFrame, assume ser um array/matriz e retorna X com nomes genéricos de features ("f0", "f1", ...).
def _prepare_X(df_or_X):
    if isinstance(df_or_X, pd.DataFrame):
        X = df_or_X.drop(columns=["Outcome"]) if "Outcome" in df_or_X.columns else df_or_X
        return X, list(X.columns)
    X = df_or_X
    return X, [f"f{i}" for i in range(X.shape[1])]


def shap_plots_for_results(df_or_X, train_results, *, max_background=200, max_samples=1000, class_index=1):
    X, feature_names = _prepare_X(df_or_X)
    X_vals = X.values if isinstance(X, pd.DataFrame) else X

    # amostragem para acelerar
    n = X_vals.shape[0]
    if n > max_samples:
        rng = np.random.default_rng(872008)
        idx = rng.choice(n, size=max_samples, replace=False)
        X_sample = X.iloc[idx] if isinstance(X, pd.DataFrame) else X_vals[idx]
    else:
        X_sample = X

    # background para explicadores genéricos
    if isinstance(X_sample, pd.DataFrame):
        bg = X_sample.sample(n=min(max_background, len(X_sample)), random_state=872008)
    else:
        if X_sample.shape[0] > max_background:
            rng = np.random.default_rng(872008)
            idx_bg = rng.choice(X_sample.shape[0], size=max_background, replace=False)
            bg = X_sample[idx_bg]
        else:
            bg = X_sample

    for tr in train_results:
        model = tr.classifier
        model_name = tr.name

        try:
            # escolhe o explainer
            if _is_tree_model(model):
                explainer = shap.TreeExplainer(model, feature_perturbation="interventional")
                shap_values = explainer(X_sample)
            elif _is_linear_model(model):
                explainer = shap.LinearExplainer(model, bg, feature_perturbation="interventional")
                shap_values = explainer(X_sample)
            else:
                if hasattr(model, "predict_proba"):
                    f = model.predict_proba
                    explainer = shap.Explainer(f, bg)
                else:
                    explainer = shap.Explainer(model, bg)
                shap_values = explainer(X_sample)

            # cria a figura, chama summary_plot SEM mostrar, define título e só então mostra
            plt.figure()
            # lida com formatos Explanation (novo) e lista/array (antigo)
            try:
                shap.summary_plot(shap_values[..., class_index],
                                  feature_names=feature_names, show=False)
            except Exception:
                if isinstance(shap_values, list) and len(shap_values) > 1:
                    sv = shap_values[class_index]
                else:
                    sv = shap_values
                shap.summary_plot(sv, feature_names=feature_names, show=False)

            # título no próprio eixo do gráfico
            ax = plt.gcf().axes[0] if plt.gcf().axes else plt.gca()
            ax.set_title(f"{model_name}")

            plt.tight_layout()
            plt.show()

        except Exception as e:
            print(f"[AVISO] Não foi possível gerar SHAP para '{model_name}': {e}")

shap_plots_for_results(x_test, models)

# Função que divide os dados em treino e teste usando train_test_split_inner, treina os modelos com train_models
# e exibe um resumo gráfico dos resultados com plot_results_summary.
def split_train_plot(dataf, scalef):
  x_train, x_test, y_train, y_test = train_test_split_inner(dataf, scalef)
  results = train_models(x_train, x_test, y_train, y_test)
  plot_results_summary(results)

split_train_plot(df, False)

split_train_plot(df, True)

split_train_plot(df_treated_with_outliers, False)

split_train_plot(df_treated_with_outliers, True)

split_train_plot(df_treated, False)

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age	Outcome
0	6	148	72	35	0	33.6	0.627	50	1
1	1	85	66	29	0	26.6	0.351	31	0
2	8	183	64	0	0	23.3	0.672	32	1
3	1	89	66	23	94	28.1	0.167	21	0
4	0	137	40	35	168	43.1	2.288	33	1
5	5	116	74	0	0	25.6	0.201	30	0
6	3	78	50	32	88	31.0	0.248	26	1
7	10	115	0	0	0	35.3	0.134	29	0
8	2	197	70	45	543	30.5	0.158	53	1
9	8	125	96	0	0	0.0	0.232	54	1

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age	Outcome
count	768.00	768.00	768.00	768.00	768.00	768.00	768.00	768.00	768.00
mean	3.85	120.89	69.11	20.54	79.80	31.99	0.47	33.24	0.35
std	3.37	31.97	19.36	15.95	115.24	7.88	0.33	11.76	0.48
min	0.00	0.00	0.00	0.00	0.00	0.00	0.08	21.00	0.00
25%	1.00	99.00	62.00	0.00	0.00	27.30	0.24	24.00	0.00
50%	3.00	117.00	72.00	23.00	30.50	32.00	0.37	29.00	0.00
75%	6.00	140.25	80.00	32.00	127.25	36.60	0.63	41.00	1.00
max	17.00	199.00	122.00	99.00	846.00	67.10	2.42	81.00	1.00

	Quantidade de zeros	Porcentagem (%)
Insulin	374	48.70
SkinThickness	227	29.56
Pregnancies	111	14.45
BloodPressure	35	4.56
BMI	11	1.43
Glucose	5	0.65
DiabetesPedigreeFunction	0	0.00
Age	0	0.00

Coluna	% de zeros	Interpretação
Insulin	48,70%	Quase metade dos registros estão zerados. Isso indica forte ausência de dados.
SkinThickness	29,56%	Também tem muitos dados faltando.
Pregnancies	14,45%	Zero pode ser um valor real, pois devem representar pessoas que nunca engravidaram.
BloodPressure	4,56%	Clinicamente, pressão 0 não faz sentido.
BMI	1,43%	Pequena quantidade, mas zero em índice de massa corporal não é válido.
Glucose	0,65%	Poucos zeros, mas glicose 0 é impossível.

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age	Outcome
Pregnancies	1.000000	0.129459	0.141282	-0.081672	-0.073535	0.017683	-0.033523	0.544341	0.221898
Glucose	0.129459	1.000000	0.152590	0.057328	0.331357	0.221071	0.137337	0.263514	0.466581
BloodPressure	0.141282	0.152590	1.000000	0.207371	0.088933	0.281805	0.041265	0.239528	0.065068
SkinThickness	-0.081672	0.057328	0.207371	1.000000	0.436783	0.392573	0.183928	-0.113970	0.074752
Insulin	-0.073535	0.331357	0.088933	0.436783	1.000000	0.197859	0.185071	-0.042163	0.130548
BMI	0.017683	0.221071	0.281805	0.392573	0.197859	1.000000	0.140647	0.036242	0.292695
DiabetesPedigreeFunction	-0.033523	0.137337	0.041265	0.183928	0.185071	0.140647	1.000000	0.033561	0.173844
Age	0.544341	0.263514	0.239528	-0.113970	-0.042163	0.036242	0.033561	1.000000	0.238356
Outcome	0.221898	0.466581	0.065068	0.074752	0.130548	0.292695	0.173844	0.238356	1.000000

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age	Outcome
0	6	148	72	35.0	0	33.6	0.627	50	1
1	1	85	66	29.0	0	26.6	0.351	31	0
2	8	183	64	30.8	0	23.3	0.672	32	1
3	1	89	66	23.0	94	28.1	0.167	21	0
4	0	137	40	35.0	168	43.1	2.288	33	1

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age
0	6	148	51.228494	12.167725	10.297460	4.124519	-0.474866	50
1	1	85	47.281764	10.708073	7.390006	3.808657	-1.088080	31
2	8	183	45.958431	11.157927	10.886361	3.632453	-0.403329	32
3	1	89	47.281764	9.118643	8.165147	3.882241	-1.912132	21
4	0	137	29.708079	12.167725	9.563902	4.468470	0.803134	33

1. Introdução¶

2. Sobre a base de dados¶

2.1 Variáveis de entradas ou "Features"¶

2.2 Saída¶

3. Importações iniciais¶

3.1 Importações de bibliotecas¶

3.2 Baixando o conjunto de dados¶

4. Exploração dos dados¶

4.1 Verificações simples¶

Gestações (Pregnancies)¶

Nível de glicose no sangue (Glucose)¶

Pressão arterial (BloodPressure)¶

Espessura da pele (SkinThickness)¶

Nível de Insulina (Insulin)¶

IMC, Indice de Massa Corporal (BMI)¶

Probabilidade genética de diabetes (DiabetesPedigreeFunction)¶

Idade (Age)¶

Resultado (Outcome)¶

Conclusões¶

4.2 Dados zerados¶

4.3 Dados duplicados¶

4.4 Visualização dos dados¶

4.4.1 Matriz de dispersão¶

O que conseguimos observar?¶

4.4.2 Histogramas¶

E agora, o que podemos observar?¶

4.4.3 Procurando por outliers com Boxplots¶

O que concluímos?¶

4.5 Correlações¶

5. Tratamento dos dados¶

5.1 Tratando valores zerados¶

Como lidar com eles? Temos várias opções dentre elas:¶

E como escolher?¶

5.1.1 Resolvendo casos simples¶

5.1.2 Usando KNN para imputar SkinThickness¶

5.1.3 Usando Regressão Linear para preenchar o Insulin¶

5.1.3 Visualização pós resolução dos zeros¶

5.2 E os outliers como ficam?¶

Log x Box-Cox¶

6. Processamento dos dados¶

6.1 Definição da semente de aleatoriedade¶

6.2 Separando entradas (X) das saídas (Y)¶

6.3 Dividindo amostras para treino e para teste¶

7. Treinamentos¶

Qual é a lógica?¶

Aprendendo¶

Prevendo¶

7.1 Importações¶

7.2 Classe para registro de resultados¶

7.3 Função para treinar os modelos¶

8. Comparações e escolha do modelo¶

8.1 Visualização para comparação¶

8.2 Qual modelo escolher?¶

8.2.1 Tempo de treino e testes¶

8.2.2 Baseline (Dummy Classifier)¶

8.2.3 Qual a métrica deveríamos priorizar?¶

Entendendo as métricas¶

Priorizando as métricas¶

8.2.4 Decisão final¶

9 Comparando os modelos escolhidos com os resultados sabidos¶

9.1 Matriz de confusão¶

9.2 Importância das entradas e SHAP¶

9.2.1 Importância (peso) das entradas¶

9.2.2 SHAP¶

O que estamos observando?¶

Comparação crítica¶

10. Conclusão¶

Apêndice 01: testando se o tratamento faz diferença¶

A01. Sem nenhum tratamento, sem o StandardScaler.¶

A02. Sem nenhum tratamento, com o StandardScaler.¶

A03. Apenas com os zeros tratados, sem tratar outliers, sem StandardScaler¶

A04. Apenas com os zeros tratados, sem tratar outliers, com StandardScaler¶

A05. Conjunto de dados tratados, porém sem StandardScaler¶

Referências¶

Gestações (`Pregnancies`)¶

Nível de glicose no sangue (`Glucose`)¶

Pressão arterial (`BloodPressure`)¶

Espessura da pele (`SkinThickness`)¶

Nível de Insulina (`Insulin`)¶

IMC, Indice de Massa Corporal (`BMI`)¶

Probabilidade genética de diabetes (`DiabetesPedigreeFunction`)¶

Idade (`Age`)¶

Resultado (`Outcome`)¶

5.1.2 Usando KNN para imputar `SkinThickness`¶

5.1.3 Usando Regressão Linear para preenchar o `Insulin`¶

A01. Sem nenhum tratamento, sem o `StandardScaler`.¶

A02. Sem nenhum tratamento, com o `StandardScaler`.¶

A03. Apenas com os zeros tratados, sem tratar outliers, sem `StandardScaler`¶

A04. Apenas com os zeros tratados, sem tratar outliers, com `StandardScaler`¶

A05. Conjunto de dados tratados, porém sem `StandardScaler`¶